home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / ldapjdk.jar / netscape / ldap / LDAPConnection.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-04-13  |  29.1 KB  |  1,658 lines
  1. package netscape.ldap;
  2.  
  3. import java.lang.reflect.Method;
  4. import java.util.Enumeration;
  5. import java.util.Hashtable;
  6. import java.util.Properties;
  7. import java.util.StringTokenizer;
  8. import java.util.Vector;
  9. import netscape.ldap.client.JDAPAVA;
  10. import netscape.ldap.client.JDAPMessage;
  11. import netscape.ldap.client.opers.JDAPAbandonRequest;
  12. import netscape.ldap.client.opers.JDAPAddRequest;
  13. import netscape.ldap.client.opers.JDAPBindRequest;
  14. import netscape.ldap.client.opers.JDAPBindResponse;
  15. import netscape.ldap.client.opers.JDAPCompareRequest;
  16. import netscape.ldap.client.opers.JDAPDeleteRequest;
  17. import netscape.ldap.client.opers.JDAPExtendedRequest;
  18. import netscape.ldap.client.opers.JDAPExtendedResponse;
  19. import netscape.ldap.client.opers.JDAPModifyRDNRequest;
  20. import netscape.ldap.client.opers.JDAPModifyRequest;
  21. import netscape.ldap.client.opers.JDAPProtocolOp;
  22. import netscape.ldap.client.opers.JDAPResult;
  23. import netscape.ldap.client.opers.JDAPSearchRequest;
  24. import netscape.ldap.client.opers.JDAPSearchResult;
  25. import netscape.ldap.client.opers.JDAPSearchResultReference;
  26.  
  27. public class LDAPConnection implements LDAPv3, Cloneable {
  28.    public static final int LDAP_VERSION = 2;
  29.    public static final String LDAP_PROPERTY_SDK = "version.sdk";
  30.    public static final String LDAP_PROPERTY_PROTOCOL = "version.protocol";
  31.    public static final String LDAP_PROPERTY_SECURITY = "version.security";
  32.    private static final String defaultFilter = "(objectClass=*)";
  33.    private static final LDAPSearchConstraints readConstraints = new LDAPSearchConstraints();
  34.    private transient LDAPSearchConstraints defaultConstraints = new LDAPSearchConstraints();
  35.    private transient Vector responseListeners;
  36.    private transient Vector searchListeners;
  37.    private transient boolean bound;
  38.    private transient String host;
  39.    private transient String[] m_hostList;
  40.    private transient int port = -1;
  41.    private transient int[] m_portList;
  42.    private transient int m_defaultPort;
  43.    private transient String prevBoundDN;
  44.    private transient String prevBoundPasswd;
  45.    private transient String boundDN;
  46.    private transient String boundPasswd;
  47.    private transient int protocolVersion = 2;
  48.    private transient LDAPSocketFactory m_factory;
  49.    // $FF: renamed from: th netscape.ldap.LDAPConnThread
  50.    private transient LDAPConnThread field_0;
  51.    private transient Vector m_attachedList = new Vector();
  52.    private transient Hashtable m_responseControlTable = new Hashtable();
  53.    private transient LDAPCache m_cache;
  54.    static Hashtable m_threadConnTable = new Hashtable();
  55.    private boolean m_anonymousBound = false;
  56.    private Object m_security;
  57.    private boolean saslBind = false;
  58.    private Object m_mechanismDriver;
  59.    private Properties m_securityProperties;
  60.    private Object m_clientCB;
  61.    private Hashtable m_methodLookup = new Hashtable();
  62.    private LDAPConnection m_referralConnection;
  63.    private static final Float SdkVersion = new Float(3.1F);
  64.    private static final Float ProtocolVersion = new Float(3.0F);
  65.    private static final String SecurityVersion = new String("none,simple,sasl");
  66.    private static final Float MajorVersion = new Float(3.0F);
  67.    private static final Float MinorVersion = new Float(0.1F);
  68.    private static final String DELIM = "#";
  69.    private static final String PersistSearchPackageName = "netscape.ldap.controls.LDAPPersistSearchControl";
  70.    private static final String EXTERNAL_MECHANISM = "SASLExternalMechanism";
  71.    private static final String EXTERNAL_MECHANISM_PACKAGE = "com.netscape.sasl.mechanisms";
  72.    public static final int MAXBACKLOG = 30;
  73.    private static boolean isCommunicator = checkCommunicator();
  74.    private static final boolean debug = false;
  75.  
  76.    public LDAPConnection() {
  77.       this.m_factory = null;
  78.    }
  79.  
  80.    public LDAPConnection(LDAPSocketFactory var1) {
  81.       this.m_factory = var1;
  82.    }
  83.  
  84.    public void finalize() throws LDAPException {
  85.       if (this.field_0 != null) {
  86.          this.disconnect();
  87.       }
  88.  
  89.    }
  90.  
  91.    public void setCache(LDAPCache var1) {
  92.       this.m_cache = var1;
  93.    }
  94.  
  95.    public LDAPCache getCache() {
  96.       return this.m_cache;
  97.    }
  98.  
  99.    public Object getProperty(String var1) throws LDAPException {
  100.       if (var1.equals("version.sdk")) {
  101.          return SdkVersion;
  102.       } else if (var1.equals("version.protocol")) {
  103.          return ProtocolVersion;
  104.       } else if (var1.equals("version.security")) {
  105.          return SecurityVersion;
  106.       } else if (var1.equals("version.major")) {
  107.          return MajorVersion;
  108.       } else {
  109.          return var1.equals("version.minor") ? MinorVersion : null;
  110.       }
  111.    }
  112.  
  113.    public void setProperty(String var1, Object var2) throws LDAPException {
  114.       throw new LDAPException("No property has been set");
  115.    }
  116.  
  117.    private void setProtocolVersion(int var1) {
  118.       this.protocolVersion = var1;
  119.    }
  120.  
  121.    public String getHost() {
  122.       return this.host;
  123.    }
  124.  
  125.    public int getPort() {
  126.       return this.port;
  127.    }
  128.  
  129.    public String getAuthenticationDN() {
  130.       return this.boundDN;
  131.    }
  132.  
  133.    public String getAuthenticationPassword() {
  134.       return this.boundPasswd;
  135.    }
  136.  
  137.    public LDAPSocketFactory getSocketFactory() {
  138.       return this.m_factory;
  139.    }
  140.  
  141.    public void setSocketFactory(LDAPSocketFactory var1) {
  142.       this.m_factory = var1;
  143.    }
  144.  
  145.    public boolean isConnected() {
  146.       Thread.yield();
  147.       return this.field_0 != null;
  148.    }
  149.  
  150.    public boolean isAuthenticated() {
  151.       return !this.bound || this.boundDN != null && !this.boundDN.equals("") && this.boundPasswd != null && !this.boundPasswd.equals("") ? this.bound : false;
  152.    }
  153.  
  154.    public void connect(String var1, int var2) throws LDAPException {
  155.       this.connect(var1, var2, (String)null, (String)null, this.defaultConstraints, false);
  156.    }
  157.  
  158.    public void connect(String var1, int var2, String var3, String var4) throws LDAPException {
  159.       this.connect(var1, var2, var3, var4, this.defaultConstraints, true);
  160.    }
  161.  
  162.    public void connect(String var1, int var2, String var3, String var4, LDAPSearchConstraints var5) throws LDAPException {
  163.       this.connect(var1, var2, var3, var4, var5, true);
  164.    }
  165.  
  166.    private void connect(String var1, int var2, String var3, String var4, LDAPSearchConstraints var5, boolean var6) throws LDAPException {
  167.       if (this.field_0 != null) {
  168.          this.disconnect();
  169.       }
  170.  
  171.       if (var1 != null && !var1.equals("")) {
  172.          this.m_defaultPort = var2;
  173.          StringTokenizer var7 = new StringTokenizer(var1);
  174.          this.m_hostList = new String[var7.countTokens()];
  175.          this.m_portList = new int[var7.countTokens()];
  176.  
  177.          for(int var8 = 0; var7.hasMoreTokens(); ++var8) {
  178.             String var9 = var7.nextToken();
  179.             int var10 = var9.indexOf(58);
  180.             if (var10 > 0) {
  181.                this.m_hostList[var8] = var9.substring(0, var10);
  182.                this.m_portList[var8] = Integer.parseInt(var9.substring(var10 + 1));
  183.             } else {
  184.                this.m_hostList[var8] = var9;
  185.                this.m_portList[var8] = this.m_defaultPort;
  186.             }
  187.          }
  188.  
  189.          LDAPException var13 = null;
  190.  
  191.          for(int var12 = 0; var12 < this.m_hostList.length; ++var12) {
  192.             try {
  193.                this.host = this.m_hostList[var12];
  194.                this.port = this.m_portList[var12];
  195.                this.connect();
  196.                var13 = null;
  197.                break;
  198.             } catch (LDAPException var11) {
  199.                var13 = var11;
  200.             }
  201.          }
  202.  
  203.          if (var13 != null) {
  204.             this.host = this.m_hostList[0];
  205.             this.port = this.m_defaultPort;
  206.             throw var13;
  207.          } else {
  208.             if (var6) {
  209.                this.authenticate(var3, var4, var5);
  210.             }
  211.  
  212.          }
  213.       } else {
  214.          throw new LDAPException("no host for connection", 89);
  215.       }
  216.    }
  217.  
  218.    public void connect(int var1, String var2, int var3, String var4, String var5) throws LDAPException {
  219.       this.connect(var1, var2, var3, var4, var5, this.defaultConstraints);
  220.    }
  221.  
  222.    public void connect(int var1, String var2, int var3, String var4, String var5, LDAPSearchConstraints var6) throws LDAPException {
  223.       this.protocolVersion = var1;
  224.       this.connect(var2, var3, var4, var5, var6);
  225.    }
  226.  
  227.    private synchronized void connect() throws LDAPException {
  228.       if (this.field_0 == null) {
  229.          if (this.host != null && this.port >= 0) {
  230.             this.field_0 = this.getNewThread(this.host, this.port, this.m_factory, this.m_cache);
  231.          } else {
  232.             throw new LDAPException("no connection parameters", 89);
  233.          }
  234.       }
  235.    }
  236.  
  237.    private synchronized LDAPConnThread getNewThread(String var1, int var2, LDAPSocketFactory var3, LDAPCache var4) throws LDAPException {
  238.       LDAPConnThread var5 = null;
  239.       Vector var6 = null;
  240.       Hashtable var7 = m_threadConnTable;
  241.       synchronized(var7){}
  242.  
  243.       try {
  244.          Enumeration var9 = m_threadConnTable.keys();
  245.          boolean var10 = false;
  246.  
  247.          while(var9.hasMoreElements()) {
  248.             LDAPConnThread var11 = (LDAPConnThread)var9.nextElement();
  249.             Vector var12 = (Vector)m_threadConnTable.get(var11);
  250.             Enumeration var13 = var12.elements();
  251.  
  252.             while(var13.hasMoreElements()) {
  253.                LDAPConnection var14 = (LDAPConnection)var13.nextElement();
  254.                if (var14.equals(this)) {
  255.                   var10 = true;
  256.                   if (!((Thread)var11).isAlive()) {
  257.                      try {
  258.                         var5 = new LDAPConnThread(var1, var2, var3, var4);
  259.                         var5.setMaxBacklog(this.getSearchConstraints().getMaxBacklog());
  260.                         var6 = (Vector)m_threadConnTable.remove(var11);
  261.                      } catch (Exception var19) {
  262.                         throw new LDAPException("unable to establish connection", 52);
  263.                      }
  264.                   }
  265.                   break;
  266.                }
  267.             }
  268.  
  269.             if (var10) {
  270.                break;
  271.             }
  272.          }
  273.  
  274.          if (!var10) {
  275.             try {
  276.                var5 = new LDAPConnThread(var1, var2, var3, var4);
  277.                var5.setMaxBacklog(this.getSearchConstraints().getMaxBacklog());
  278.                var6 = new Vector();
  279.                var6.addElement(this);
  280.             } catch (Exception var18) {
  281.                throw new LDAPException("unable to establish connection", 52);
  282.             }
  283.          }
  284.  
  285.          if (var5 != null) {
  286.             m_threadConnTable.put(var5, var6);
  287.             int var21 = 0;
  288.  
  289.             for(int var22 = var6.size(); var21 < var22; ++var21) {
  290.                LDAPConnection var23 = (LDAPConnection)var6.elementAt(var21);
  291.                var5.register(var23);
  292.                var23.field_0 = var5;
  293.             }
  294.          }
  295.       } catch (Throwable var20) {
  296.          throw var20;
  297.       }
  298.  
  299.       this.authenticateSSLConnection();
  300.       return var5;
  301.    }
  302.  
  303.    private void authenticateSSLConnection() throws LDAPException {
  304.       if (this.m_factory != null && this.m_factory instanceof LDAPSSLSocketFactoryExt) {
  305.          boolean var1 = ((LDAPSSLSocketFactoryExt)this.m_factory).isClientAuth();
  306.          if (var1) {
  307.             this.authenticate((String)null, (String)"SASLExternalMechanism", "com.netscape.sasl.mechanisms", (Properties)null, (Object)null);
  308.          }
  309.       }
  310.  
  311.    }
  312.  
  313.    public void abandon(LDAPSearchResults var1) throws LDAPException {
  314.       if (this.field_0 != null && var1 != null) {
  315.          var1.abandon();
  316.          int var2 = var1.getID();
  317.  
  318.          for(int var3 = 0; var3 < 3; ++var3) {
  319.             try {
  320.                this.field_0.abandon(var2);
  321.                this.field_0.sendRequest(new JDAPAbandonRequest(var2), (LDAPResponseListener)null, this.defaultConstraints);
  322.                break;
  323.             }
  324.          }
  325.  
  326.          if (this.field_0 == null) {
  327.             throw new LDAPException("Failed to send abandon request to the server.", 80);
  328.          }
  329.       }
  330.    }
  331.  
  332.    public void authenticate(String var1, String var2) throws LDAPException {
  333.       this.authenticate(this.protocolVersion, var1, var2, this.defaultConstraints);
  334.    }
  335.  
  336.    public void authenticate(String var1, String var2, LDAPSearchConstraints var3) throws LDAPException {
  337.       this.authenticate(this.protocolVersion, var1, var2, var3);
  338.    }
  339.  
  340.    public void authenticate(int var1, String var2, String var3) throws LDAPException {
  341.       this.authenticate(var1, var2, var3, this.defaultConstraints);
  342.    }
  343.  
  344.    public void authenticate(int var1, String var2, String var3, LDAPSearchConstraints var4) throws LDAPException {
  345.       this.prevBoundDN = this.boundDN;
  346.       this.prevBoundPasswd = this.boundPasswd;
  347.       this.boundDN = var2;
  348.       this.boundPasswd = var3;
  349.       if (this.prevBoundDN != null && this.prevBoundPasswd != null) {
  350.          this.m_anonymousBound = false;
  351.       } else {
  352.          this.m_anonymousBound = true;
  353.       }
  354.  
  355.       this.bind(var1, true, var4);
  356.    }
  357.  
  358.    public void authenticate(String var1, String var2, String var3, Properties var4, Object var5) throws LDAPException {
  359.       try {
  360.          Object[] var6 = new Object[]{var2, var3};
  361.          String[] var7 = new String[]{"java.lang.String", "java.lang.String"};
  362.          this.m_mechanismDriver = this.invokeMethod((Object)null, "com.netscape.sasl.SASLMechanismFactory", "getMechanismDriver", var6, var7);
  363.       } catch (Exception var8) {
  364.          throw new LDAPException(((Throwable)var8).toString(), 80);
  365.       }
  366.  
  367.       this.m_securityProperties = var4;
  368.       this.m_clientCB = var5;
  369.       this.boundDN = var1;
  370.       this.saslBind(true);
  371.    }
  372.  
  373.    public void authenticate(String var1, String[] var2, String var3, Properties var4, Object var5) throws LDAPException {
  374.       for(int var6 = 0; var6 < var2.length; ++var6) {
  375.          try {
  376.             this.authenticate(var1, var2[var6], var3, var4, var5);
  377.             if (this.m_mechanismDriver != null) {
  378.                return;
  379.             }
  380.          } catch (LDAPException var7) {
  381.          }
  382.       }
  383.  
  384.       throw new LDAPException("Failed to get mechanism driver", 80);
  385.    }
  386.  
  387.    private void saslBind(boolean var1) throws LDAPException {
  388.       this.saslBind = true;
  389.       this.protocolVersion = 3;
  390.       if (this.field_0 == null) {
  391.          this.bound = false;
  392.          this.field_0 = null;
  393.          this.connect();
  394.       }
  395.  
  396.       if (this.bound && var1 && this.field_0.getClientCount() > 1) {
  397.          this.disconnect();
  398.          this.connect();
  399.       }
  400.  
  401.       if (this.bound && var1 || !this.bound) {
  402.          try {
  403.             Object[] var2 = new Object[]{this.boundDN, "LDAP", null, this.m_securityProperties, this.m_clientCB};
  404.             String[] var3 = new String[]{"java.lang.String", "java.lang.String", "java.lang.String", "java.util.Properties", "com.netscape.sasl.SASLClientCB"};
  405.             String var4 = this.m_mechanismDriver.getClass().getName();
  406.             byte[] var5 = (byte[])this.invokeMethod(this.m_mechanismDriver, var4, "startAuthentication", var2, var3);
  407.             boolean var6 = this.isExternalMechanism(var4);
  408.             int var7 = 14;
  409.             Object var8 = null;
  410.  
  411.             while(true) {
  412.                boolean var10000;
  413.                if (var7 == 0) {
  414.                   var10000 = true;
  415.                } else {
  416.                   if (var7 != 14) {
  417.                      throw new LDAPException("Authentication failed", var7);
  418.                   }
  419.  
  420.                   var10000 = false;
  421.                }
  422.  
  423.                if (var10000) {
  424.                   Boolean var16 = (Boolean)this.invokeMethod(this.m_mechanismDriver, var4, "isComplete", (Object[])null, (String[])null);
  425.                   if (!var16) {
  426.                      throw new LDAPException("The server indicates that authentication is successful, but the SASL driver indicates that authentication is not yet done.", 80);
  427.                   }
  428.  
  429.                   this.m_security = this.invokeMethod(this.m_mechanismDriver, var4, "getSecurityLayer", (Object[])null, (String[])null);
  430.                   this.field_0.setSecurityLayer(this.m_security);
  431.                   this.updateThreadConnTable();
  432.                   return;
  433.                }
  434.  
  435.                JDAPBindResponse var15 = this.saslBind(var5);
  436.                var7 = ((JDAPResult)var15).getResultCode();
  437.                if (!var6) {
  438.                   String var9 = var15.getCredentials();
  439.                   byte[] var10 = var9.getBytes();
  440.                   Object[] var11 = new Object[]{var10};
  441.                   String[] var12 = new String[]{"[B"};
  442.                   var5 = (byte[])this.invokeMethod(this.m_mechanismDriver, var4, "evaluateResponse", var11, var12);
  443.                }
  444.             }
  445.          } catch (LDAPException var13) {
  446.             throw var13;
  447.          } catch (Exception var14) {
  448.             throw new LDAPException(((Throwable)var14).toString(), 80);
  449.          }
  450.       }
  451.    }
  452.  
  453.    private boolean isExternalMechanism(String var1) {
  454.       String var2 = var1;
  455.       int var3 = var1.lastIndexOf(46);
  456.       if (var3 >= 0 && var3 < var1.length() - 1) {
  457.          var2 = var1.substring(var3 + 1);
  458.       }
  459.  
  460.       return var2.equals("SASLExternalMechanism");
  461.    }
  462.  
  463.    private Object invokeMethod(Object var1, String var2, String var3, Object[] var4, String[] var5) throws LDAPException {
  464.       try {
  465.          Method var6 = this.getMethod(var2, var3, var5);
  466.          return var6 != null ? var6.invoke(var1, var4) : null;
  467.       } catch (Exception var7) {
  468.          throw new LDAPException("Invoking " + var3 + ": " + ((Throwable)var7).toString(), 89);
  469.       }
  470.    }
  471.  
  472.    private Method getMethod(String var1, String var2, String[] var3) throws LDAPException {
  473.       try {
  474.          Object var4 = null;
  475.          String var5 = "";
  476.          if (var3 != null) {
  477.             for(int var6 = 0; var6 < var3.length; ++var6) {
  478.                var5 = var5 + var3[var6].getClass().getName();
  479.             }
  480.          }
  481.  
  482.          String var13 = var1 + "." + var2 + "." + var5;
  483.          Method var12;
  484.          if ((var12 = (Method)this.m_methodLookup.get(var13)) != null) {
  485.             return var12;
  486.          } else {
  487.             Class var7 = Class.forName(var1);
  488.             Method[] var8 = var7.getMethods();
  489.  
  490.             for(int var9 = 0; var9 < var8.length; ++var9) {
  491.                Class[] var10 = var8[var9].getParameterTypes();
  492.                if (var8[var9].getName().equals(var2) && this.signatureCorrect(var10, var3)) {
  493.                   this.m_methodLookup.put(var13, var8[var9]);
  494.                   return var8[var9];
  495.                }
  496.             }
  497.  
  498.             throw new LDAPException("Method " + var2 + " not found in " + var1);
  499.          }
  500.       } catch (ClassNotFoundException var11) {
  501.          throw new LDAPException("Class " + var1 + " not found");
  502.       }
  503.    }
  504.  
  505.    private boolean signatureCorrect(Class[] var1, String[] var2) {
  506.       if (var2 == null) {
  507.          return true;
  508.       } else if (var1.length != var2.length) {
  509.          return false;
  510.       } else {
  511.          for(int var3 = 0; var3 < var1.length; ++var3) {
  512.             if (!var1[var3].getName().equals(var2[var3])) {
  513.                return false;
  514.             }
  515.          }
  516.  
  517.          return true;
  518.       }
  519.    }
  520.  
  521.    private boolean checkForSASLBindCompletion(int var1) throws LDAPException {
  522.       if (var1 == 0) {
  523.          return true;
  524.       } else if (var1 == 14) {
  525.          return false;
  526.       } else {
  527.          throw new LDAPException("Authentication failed", var1);
  528.       }
  529.    }
  530.  
  531.    private JDAPBindResponse saslBind(byte[] var1) throws LDAPException {
  532.       this.saslBind = true;
  533.       if (this.field_0 == null) {
  534.          this.connect();
  535.       }
  536.  
  537.       LDAPResponseListener var2 = this.getResponseListener();
  538.  
  539.       JDAPBindResponse var4;
  540.       try {
  541.          String var7 = (String)this.invokeMethod(this.m_mechanismDriver, this.m_mechanismDriver.getClass().getName(), "getMechanismName", (Object[])null, (String[])null);
  542.          this.sendRequest(new JDAPBindRequest(this.protocolVersion, this.boundDN, var7, var1), var2, this.defaultConstraints);
  543.          JDAPMessage var3 = var2.getResponse();
  544.          JDAPProtocolOp var8 = var3.getProtocolOp();
  545.          if (!(var8 instanceof JDAPBindResponse)) {
  546.             throw new LDAPException("Unknown response from the server during SASL bind", 80);
  547.          }
  548.  
  549.          var4 = (JDAPBindResponse)var8;
  550.       } finally {
  551.          this.releaseResponseListener(var2);
  552.       }
  553.  
  554.       return var4;
  555.    }
  556.  
  557.    private void bind(int var1, boolean var2, LDAPSearchConstraints var3) throws LDAPException {
  558.       this.saslBind = false;
  559.       if (this.field_0 == null) {
  560.          this.bound = false;
  561.          this.field_0 = null;
  562.          this.connect();
  563.       } else if (!this.bound && var2 && this.field_0.getClientCount() > 1) {
  564.          this.disconnect();
  565.          this.connect();
  566.       }
  567.  
  568.       if (!this.bound || var2) {
  569.          if (this.m_anonymousBound || this.boundDN != null && this.boundPasswd != null || var2) {
  570.             if (this.bound && var2) {
  571.                if (this.protocolVersion == var1) {
  572.                   if (this.m_anonymousBound && (this.boundDN == null || this.boundPasswd == null)) {
  573.                      return;
  574.                   }
  575.  
  576.                   if (!this.m_anonymousBound && this.boundDN != null && this.boundPasswd != null && this.boundDN.equals(this.prevBoundDN) && this.boundPasswd.equals(this.prevBoundPasswd)) {
  577.                      return;
  578.                   }
  579.                }
  580.  
  581.                if (this.field_0.getClientCount() > 1) {
  582.                   this.disconnect();
  583.                   this.connect();
  584.                }
  585.             }
  586.  
  587.             this.protocolVersion = var1;
  588.             LDAPResponseListener var4 = this.getResponseListener();
  589.  
  590.             try {
  591.                if (this.m_referralConnection != null) {
  592.                   this.m_referralConnection.disconnect();
  593.                   this.m_referralConnection = null;
  594.                }
  595.  
  596.                this.sendRequest(new JDAPBindRequest(this.protocolVersion, this.boundDN, this.boundPasswd), var4, var3);
  597.                JDAPMessage var5 = var4.getResponse();
  598.                this.checkMsg(var5);
  599.             } catch (LDAPReferralException var11) {
  600.                this.m_referralConnection = this.createReferralConnection(var11, var3);
  601.             } finally {
  602.                this.releaseResponseListener(var4);
  603.             }
  604.  
  605.             this.updateThreadConnTable();
  606.          }
  607.       }
  608.    }
  609.  
  610.    private void updateThreadConnTable() {
  611.       Hashtable var1 = m_threadConnTable;
  612.       synchronized(var1){}
  613.  
  614.       try {
  615.          if (m_threadConnTable.containsKey(this.field_0)) {
  616.             Vector var3 = (Vector)m_threadConnTable.get(this.field_0);
  617.             int var4 = 0;
  618.  
  619.             for(int var5 = var3.size(); var4 < var5; ++var4) {
  620.                LDAPConnection var6 = (LDAPConnection)var3.elementAt(var4);
  621.                var6.bound = true;
  622.             }
  623.          }
  624.       } catch (Throwable var8) {
  625.          throw var8;
  626.       }
  627.  
  628.    }
  629.  
  630.    private void sendRequest(JDAPProtocolOp var1, LDAPResponseListener var2, LDAPSearchConstraints var3) throws LDAPException {
  631.       for(int var4 = 0; var4 < 3; ++var4) {
  632.          try {
  633.             this.field_0.sendRequest(var1, var2, var3);
  634.             break;
  635.          }
  636.       }
  637.  
  638.       if (this.field_0 == null) {
  639.          throw new LDAPException("The connection is not available", 80);
  640.       }
  641.    }
  642.  
  643.    private void bind(LDAPSearchConstraints var1) throws LDAPException {
  644.       if (this.saslBind) {
  645.          this.saslBind(false);
  646.       } else {
  647.          this.bind(this.protocolVersion, false, var1);
  648.       }
  649.    }
  650.  
  651.    public synchronized void disconnect() throws LDAPException {
  652.       if (this.m_referralConnection != null) {
  653.          this.m_referralConnection.disconnect();
  654.          this.m_referralConnection = null;
  655.       }
  656.  
  657.       if (this.field_0 == null) {
  658.          throw new LDAPException("unable to disconnect() without connecting", 80);
  659.       } else {
  660.          if (this.m_cache != null) {
  661.             this.m_cache.cleanup();
  662.             this.m_cache = null;
  663.          }
  664.  
  665.          this.deleteThreadConnEntry();
  666.          this.deregisterConnection();
  667.       }
  668.    }
  669.  
  670.    private void deleteThreadConnEntry() {
  671.       Hashtable var1 = m_threadConnTable;
  672.       synchronized(var1){}
  673.  
  674.       try {
  675.          Enumeration var3 = m_threadConnTable.keys();
  676.  
  677.          while(var3.hasMoreElements()) {
  678.             LDAPConnThread var4 = (LDAPConnThread)var3.nextElement();
  679.             Vector var5 = (Vector)m_threadConnTable.get(var4);
  680.             Enumeration var6 = var5.elements();
  681.  
  682.             while(var6.hasMoreElements()) {
  683.                LDAPConnection var7 = (LDAPConnection)var6.nextElement();
  684.                if (var7.equals(this)) {
  685.                   var5.removeElement(var7);
  686.                   if (var5.size() == 0) {
  687.                      m_threadConnTable.remove(var4);
  688.                   }
  689.  
  690.                   return;
  691.                }
  692.             }
  693.          }
  694.  
  695.       } catch (Throwable var9) {
  696.          throw var9;
  697.       }
  698.    }
  699.  
  700.    synchronized void deregisterConnection() {
  701.       this.field_0.deregister(this);
  702.       this.field_0 = null;
  703.       this.bound = false;
  704.    }
  705.  
  706.    public LDAPEntry read(String var1) throws LDAPException {
  707.       return this.read(var1, (String[])null, this.defaultConstraints);
  708.    }
  709.  
  710.    public LDAPEntry read(String var1, LDAPSearchConstraints var2) throws LDAPException {
  711.       return this.read(var1, (String[])null, var2);
  712.    }
  713.  
  714.    public LDAPEntry read(String var1, String[] var2) throws LDAPException {
  715.       return this.read(var1, var2, this.defaultConstraints);
  716.    }
  717.  
  718.    public LDAPEntry read(String var1, String[] var2, LDAPSearchConstraints var3) throws LDAPException {
  719.       LDAPSearchResults var4 = this.search(var1, 0, "(objectClass=*)", var2, false, var3);
  720.       return var4 == null ? null : var4.next();
  721.    }
  722.  
  723.    public static LDAPEntry read(LDAPUrl var0) throws LDAPException {
  724.       String var1 = var0.getHost();
  725.       int var2 = var0.getPort();
  726.       if (var1 == null) {
  727.          throw new LDAPException("no host for connection", 89);
  728.       } else {
  729.          String[] var3 = var0.getAttributeArray();
  730.          String var4 = var0.getDN();
  731.          LDAPConnection var6 = new LDAPConnection();
  732.          var6.connect(var1, var2);
  733.          LDAPEntry var5 = var6.read(var4, var3);
  734.          var6.disconnect();
  735.          return var5;
  736.       }
  737.    }
  738.  
  739.    public static LDAPSearchResults search(LDAPUrl var0) throws LDAPException {
  740.       return search(var0, (LDAPSearchConstraints)null);
  741.    }
  742.  
  743.    public static LDAPSearchResults search(LDAPUrl var0, LDAPSearchConstraints var1) throws LDAPException {
  744.       String var2 = var0.getHost();
  745.       int var3 = var0.getPort();
  746.       if (var2 == null) {
  747.          throw new LDAPException("no host for connection", 89);
  748.       } else {
  749.          String[] var4 = var0.getAttributeArray();
  750.          String var5 = var0.getDN();
  751.          String var6 = var0.getFilter();
  752.          if (var6 == null) {
  753.             var6 = "(objectClass=*)";
  754.          }
  755.  
  756.          int var7 = var0.getScope();
  757.          LDAPConnection var8 = new LDAPConnection();
  758.          var8.connect(var2, var3);
  759.          LDAPSearchResults var9;
  760.          if (var1 != null) {
  761.             var9 = var8.search(var5, var7, var6, var4, false, var1);
  762.          } else {
  763.             var9 = var8.search(var5, var7, var6, var4, false);
  764.          }
  765.  
  766.          var9.closeOnCompletion(var8);
  767.          return var9;
  768.       }
  769.    }
  770.  
  771.    public LDAPSearchResults search(String var1, int var2, String var3, String[] var4, boolean var5) throws LDAPException {
  772.       return this.search(var1, var2, var3, var4, var5, this.defaultConstraints);
  773.    }
  774.  
  775.    public LDAPSearchResults search(String var1, int var2, String var3, String[] var4, boolean var5, LDAPSearchConstraints var6) throws LDAPException {
  776.       if (var6 == null) {
  777.          var6 = this.defaultConstraints;
  778.       }
  779.  
  780.       LDAPSearchResults var7 = new LDAPSearchResults(this, var6, var1, var2, var3, var4, var5);
  781.       Object var8 = null;
  782.       Long var9 = null;
  783.       boolean var10 = true;
  784.  
  785.       try {
  786.          if (this.m_cache != null) {
  787.             var9 = this.m_cache.createKey(this.host, this.port, var1, var3, var2, var4, this.boundDN, var6);
  788.             Vector var60 = (Vector)this.m_cache.getEntry(var9);
  789.             if (var60 != null) {
  790.                return new LDAPSearchResults(var60, this, var6, var1, var2, var3, var4, var5);
  791.             }
  792.          }
  793.       } catch (LDAPException var53) {
  794.          var10 = false;
  795.          String var12 = "Exception: " + var53;
  796.       }
  797.  
  798.       if (this.saslBind) {
  799.          this.saslBind(false);
  800.       } else {
  801.          this.bind(this.protocolVersion, false, var6);
  802.       }
  803.  
  804.       LDAPSearchListener var11 = this.getSearchListener(var6);
  805.       int var61 = var6.getDereference();
  806.       JDAPSearchRequest var13 = new JDAPSearchRequest(var1, var2, var61, var6.getMaxResults(), var6.getTimeLimit(), var5, var3, var4);
  807.       synchronized(var11){}
  808.  
  809.       try {
  810.          boolean var16 = false;
  811.  
  812.          try {
  813.             this.sendRequest(var13, var11, var6);
  814.             var16 = true;
  815.          } finally {
  816.             if (!var16) {
  817.                this.releaseSearchListener(var11);
  818.             }
  819.  
  820.          }
  821.  
  822.          if (this.m_cache != null && var10) {
  823.             var11.setKey(var9);
  824.          }
  825.       } catch (Throwable var55) {
  826.          throw var55;
  827.       }
  828.  
  829.       if (var6.getBatchSize() == 0) {
  830.          try {
  831.             JDAPMessage var64 = ((LDAPResponseListener)var11).getResponse();
  832.             Enumeration var17 = var11.getSearchResults();
  833.  
  834.             try {
  835.                this.checkSearchMsg(var7, var64, var6, var1, var2, var3, var4, var5);
  836.             } catch (LDAPException var56) {
  837.                JDAPProtocolOp var19 = var64.getProtocolOp();
  838.                if (!(var19 instanceof JDAPSearchResultReference) && !(var19 instanceof JDAPSearchResult)) {
  839.                   throw var56;
  840.                }
  841.  
  842.                System.err.println("LDAPConnection.checkSearchMsg: ignoring bad referral");
  843.             }
  844.  
  845.             while(var17.hasMoreElements()) {
  846.                JDAPMessage var18 = (JDAPMessage)var17.nextElement();
  847.                this.checkSearchMsg(var7, var18, var6, var1, var2, var3, var4, var5);
  848.             }
  849.          } catch (LDAPException var57) {
  850.             throw var57;
  851.          } finally {
  852.             this.releaseSearchListener(var11);
  853.          }
  854.       } else {
  855.          JDAPMessage var14 = var11.nextResult();
  856.          if (var14 == null) {
  857.             var14 = ((LDAPResponseListener)var11).getResponse();
  858.  
  859.             try {
  860.                this.checkSearchMsg(var7, var14, var6, var1, var2, var3, var4, var5);
  861.             } finally {
  862.                this.releaseSearchListener(var11);
  863.             }
  864.          } else {
  865.             try {
  866.                this.checkSearchMsg(var7, var14, var6, var1, var2, var3, var4, var5);
  867.             } catch (LDAPException var59) {
  868.                if (!(var14.getProtocolOp() instanceof JDAPSearchResultReference)) {
  869.                   throw var59;
  870.                }
  871.  
  872.                System.err.println("LDAPConnection.checkSearchMsg: ignoring bad referral");
  873.             }
  874.  
  875.             LDAPControl[] var15 = (LDAPControl[])getOption(12, var6);
  876.  
  877.             for(int var63 = 0; var15 != null && var63 < var15.length; ++var63) {
  878.                if (var15[var63].getClass().getName().equals("netscape.ldap.controls.LDAPPersistSearchControl")) {
  879.                   var7.associatePersistentSearch(var11);
  880.                   return var7;
  881.                }
  882.             }
  883.  
  884.             var7.associate(var11);
  885.          }
  886.       }
  887.  
  888.       return var7;
  889.    }
  890.  
  891.    void checkSearchMsg(LDAPSearchResults var1, JDAPMessage var2, LDAPSearchConstraints var3, String var4, int var5, String var6, String[] var7, boolean var8) throws LDAPException {
  892.       try {
  893.          this.checkMsg(var2);
  894.          if (var2.getProtocolOp().getType() != 5) {
  895.             var1.add(var2.getProtocolOp());
  896.          }
  897.       } catch (LDAPReferralException var12) {
  898.          Vector var10 = new Vector();
  899.          this.performReferrals((LDAPReferralException)var12, var3, 3, var4, var5, var6, var7, var8, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, var10);
  900.  
  901.          for(int var11 = 0; var11 < var10.size(); ++var11) {
  902.             var1.addReferralEntries((LDAPSearchResults)var10.elementAt(var11));
  903.          }
  904.  
  905.          Object var14 = null;
  906.       } catch (LDAPException var13) {
  907.          if (var13.getLDAPResultCode() != 11 && var13.getLDAPResultCode() != 3 && var13.getLDAPResultCode() != 4) {
  908.             throw var13;
  909.          } else {
  910.             var1.add(var13);
  911.          }
  912.       }
  913.    }
  914.  
  915.    public boolean compare(String var1, LDAPAttribute var2) throws LDAPException {
  916.       return this.compare(var1, var2, this.defaultConstraints);
  917.    }
  918.  
  919.    public boolean compare(String var1, LDAPAttribute var2, LDAPSearchConstraints var3) throws LDAPException {
  920.       if (this.saslBind) {
  921.          this.saslBind(false);
  922.       } else {
  923.          this.bind(this.protocolVersion, false, var3);
  924.       }
  925.  
  926.       LDAPResponseListener var4 = this.getResponseListener();
  927.       Enumeration var5 = var2.getByteValues();
  928.       byte[] var6 = (byte[])var5.nextElement();
  929.       String var7 = "";
  930.  
  931.       try {
  932.          var7 = new String(var6, "UTF8");
  933.       } catch (Throwable var19) {
  934.       }
  935.  
  936.       JDAPAVA var8 = new JDAPAVA(var2.getName(), var7);
  937.  
  938.       boolean var22;
  939.       try {
  940.          this.sendRequest(new JDAPCompareRequest(var1, var8), var4, var3);
  941.          JDAPMessage var9 = var4.getResponse();
  942.          int var13 = ((JDAPResult)var9.getProtocolOp()).getResultCode();
  943.          if (var13 != 5) {
  944.             if (var13 == 6) {
  945.                var22 = true;
  946.                return var22;
  947.             }
  948.  
  949.             this.checkMsg(var9);
  950.             return false;
  951.          }
  952.  
  953.          var22 = false;
  954.       } catch (LDAPReferralException var20) {
  955.          Vector var14 = new Vector();
  956.          this.performReferrals((LDAPReferralException)var20, var3, 14, var1, 0, (String)null, (String[])null, false, (LDAPModification[])null, (LDAPEntry)null, var2, var14);
  957.          boolean var15 = false;
  958.          if (var14.size() > 0) {
  959.             var15 = (Boolean)var14.elementAt(0);
  960.          }
  961.  
  962.          Object var24 = null;
  963.          var22 = var15;
  964.          return var22;
  965.       } finally {
  966.          this.releaseResponseListener(var4);
  967.       }
  968.  
  969.       return var22;
  970.    }
  971.  
  972.    public void add(LDAPEntry var1) throws LDAPException {
  973.       this.add(var1, this.defaultConstraints);
  974.    }
  975.  
  976.    public void add(LDAPEntry var1, LDAPSearchConstraints var2) throws LDAPException {
  977.       if (this.saslBind) {
  978.          this.saslBind(false);
  979.       } else {
  980.          this.bind(this.protocolVersion, false, var2);
  981.       }
  982.  
  983.       LDAPResponseListener var3 = this.getResponseListener();
  984.       LDAPAttributeSet var4 = var1.getAttributeSet();
  985.       LDAPAttribute[] var5 = new LDAPAttribute[var4.size()];
  986.  
  987.       for(int var6 = 0; var6 < var4.size(); ++var6) {
  988.          var5[var6] = var4.elementAt(var6);
  989.       }
  990.  
  991.       try {
  992.          this.sendRequest(new JDAPAddRequest(var1.getDN(), var5), var3, var2);
  993.          JDAPMessage var7 = var3.getResponse();
  994.          this.checkMsg(var7);
  995.       } catch (LDAPReferralException var13) {
  996.          this.performReferrals((LDAPReferralException)var13, var2, 8, (String)null, 0, (String)null, (String[])null, false, (LDAPModification[])null, var1, (LDAPAttribute)null, (Vector)null);
  997.       } finally {
  998.          this.releaseResponseListener(var3);
  999.       }
  1000.  
  1001.    }
  1002.  
  1003.    public LDAPExtendedOperation extendedOperation(LDAPExtendedOperation var1) throws LDAPException {
  1004.       return this.extendedOperation(var1, this.defaultConstraints);
  1005.    }
  1006.  
  1007.    public LDAPExtendedOperation extendedOperation(LDAPExtendedOperation var1, LDAPSearchConstraints var2) throws LDAPException {
  1008.       if (this.saslBind) {
  1009.          this.saslBind(false);
  1010.       } else {
  1011.          this.bind(this.protocolVersion, false, var2);
  1012.       }
  1013.  
  1014.       LDAPResponseListener var3 = this.getResponseListener();
  1015.       Object var4 = null;
  1016.       Object var5 = null;
  1017.  
  1018.       LDAPExtendedOperation var7;
  1019.       try {
  1020.          this.sendRequest(new JDAPExtendedRequest(var1.getID(), var1.getValue()), var3, var2);
  1021.          JDAPMessage var15 = var3.getResponse();
  1022.          this.checkMsg(var15);
  1023.          JDAPExtendedResponse var10 = (JDAPExtendedResponse)var15.getProtocolOp();
  1024.          byte[] var16 = var10.getValue();
  1025.          String var6 = var10.getID();
  1026.          return new LDAPExtendedOperation(var6, var16);
  1027.       } catch (LDAPReferralException var13) {
  1028.          var7 = this.performExtendedReferrals(var13, var2, var1);
  1029.       } finally {
  1030.          this.releaseResponseListener(var3);
  1031.       }
  1032.  
  1033.       return var7;
  1034.    }
  1035.  
  1036.    public void modify(String var1, LDAPModification var2) throws LDAPException {
  1037.       this.modify(var1, var2, this.defaultConstraints);
  1038.    }
  1039.  
  1040.    public void modify(String var1, LDAPModification var2, LDAPSearchConstraints var3) throws LDAPException {
  1041.       LDAPModification[] var4 = new LDAPModification[]{var2};
  1042.       this.modify(var1, var4, var3);
  1043.    }
  1044.  
  1045.    public void modify(String var1, LDAPModificationSet var2) throws LDAPException {
  1046.       this.modify(var1, var2, this.defaultConstraints);
  1047.    }
  1048.  
  1049.    public void modify(String var1, LDAPModificationSet var2, LDAPSearchConstraints var3) throws LDAPException {
  1050.       LDAPModification[] var4 = new LDAPModification[var2.size()];
  1051.  
  1052.       for(int var5 = 0; var5 < var2.size(); ++var5) {
  1053.          var4[var5] = var2.elementAt(var5);
  1054.       }
  1055.  
  1056.       this.modify(var1, var4, var3);
  1057.    }
  1058.  
  1059.    public void modify(String var1, LDAPModification[] var2) throws LDAPException {
  1060.       this.modify(var1, var2, this.defaultConstraints);
  1061.    }
  1062.  
  1063.    public void modify(String var1, LDAPModification[] var2, LDAPSearchConstraints var3) throws LDAPException {
  1064.       if (this.saslBind) {
  1065.          this.saslBind(false);
  1066.       } else {
  1067.          this.bind(this.protocolVersion, false, var3);
  1068.       }
  1069.  
  1070.       LDAPResponseListener var4 = this.getResponseListener();
  1071.       Object var5 = null;
  1072.  
  1073.       try {
  1074.          this.sendRequest(new JDAPModifyRequest(var1, var2), var4, var3);
  1075.          JDAPMessage var13 = var4.getResponse();
  1076.          this.checkMsg(var13);
  1077.       } catch (LDAPReferralException var11) {
  1078.          this.performReferrals((LDAPReferralException)var11, var3, 6, var1, 0, (String)null, (String[])null, false, var2, (LDAPEntry)null, (LDAPAttribute)null, (Vector)null);
  1079.       } finally {
  1080.          this.releaseResponseListener(var4);
  1081.       }
  1082.  
  1083.    }
  1084.  
  1085.    public void delete(String var1) throws LDAPException {
  1086.       this.delete(var1, this.defaultConstraints);
  1087.    }
  1088.  
  1089.    public void delete(String var1, LDAPSearchConstraints var2) throws LDAPException {
  1090.       if (this.saslBind) {
  1091.          this.saslBind(false);
  1092.       } else {
  1093.          this.bind(this.protocolVersion, false, var2);
  1094.       }
  1095.  
  1096.       LDAPResponseListener var3 = this.getResponseListener();
  1097.  
  1098.       try {
  1099.          this.sendRequest(new JDAPDeleteRequest(var1), var3, var2);
  1100.          JDAPMessage var4 = var3.getResponse();
  1101.          this.checkMsg(var4);
  1102.       } catch (LDAPReferralException var10) {
  1103.          this.performReferrals((LDAPReferralException)var10, var2, 10, var1, 0, (String)null, (String[])null, false, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, (Vector)null);
  1104.       } finally {
  1105.          this.releaseResponseListener(var3);
  1106.       }
  1107.  
  1108.    }
  1109.  
  1110.    public void rename(String var1, String var2, boolean var3) throws LDAPException {
  1111.       this.rename(var1, var2, (String)null, var3);
  1112.    }
  1113.  
  1114.    public void rename(String var1, String var2, boolean var3, LDAPSearchConstraints var4) throws LDAPException {
  1115.       this.rename(var1, var2, (String)null, var3, var4);
  1116.    }
  1117.  
  1118.    public void rename(String var1, String var2, String var3, boolean var4) throws LDAPException {
  1119.       this.rename(var1, var2, var3, var4, this.defaultConstraints);
  1120.    }
  1121.  
  1122.    public void rename(String var1, String var2, String var3, boolean var4, LDAPSearchConstraints var5) throws LDAPException {
  1123.       if (this.saslBind) {
  1124.          this.saslBind(false);
  1125.       } else {
  1126.          this.bind(this.protocolVersion, false, var5);
  1127.       }
  1128.  
  1129.       LDAPResponseListener var6 = this.getResponseListener();
  1130.  
  1131.       try {
  1132.          Object var10 = null;
  1133.          JDAPModifyRDNRequest var15;
  1134.          if (var3 != null) {
  1135.             var15 = new JDAPModifyRDNRequest(var1, var2, var4, var3);
  1136.          } else {
  1137.             var15 = new JDAPModifyRDNRequest(var1, var2, var4);
  1138.          }
  1139.  
  1140.          this.sendRequest(var15, var6, var5);
  1141.          JDAPMessage var7 = var6.getResponse();
  1142.          this.checkMsg(var7);
  1143.       } catch (LDAPReferralException var13) {
  1144.          this.performReferrals((LDAPReferralException)var13, var5, 12, var1, 0, var2, (String[])null, var4, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, (Vector)null);
  1145.       } finally {
  1146.          this.releaseResponseListener(var6);
  1147.       }
  1148.  
  1149.    }
  1150.  
  1151.    public Object getOption(int var1) throws LDAPException {
  1152.       return var1 == 17 ? new Integer(this.protocolVersion) : getOption(var1, this.defaultConstraints);
  1153.    }
  1154.  
  1155.    private static Object getOption(int var0, LDAPSearchConstraints var1) throws LDAPException {
  1156.       switch (var0) {
  1157.          case 2:
  1158.             return new Integer(var1.getDereference());
  1159.          case 3:
  1160.             return new Integer(var1.getMaxResults());
  1161.          case 4:
  1162.             return new Integer(var1.getTimeLimit());
  1163.          case 8:
  1164.             return new Boolean(var1.getReferrals());
  1165.          case 9:
  1166.             return var1.getRebindProc();
  1167.          case 10:
  1168.             return new Integer(var1.getHopLimit());
  1169.          case 11:
  1170.             return var1.getClientControls();
  1171.          case 12:
  1172.             return var1.getServerControls();
  1173.          case 20:
  1174.             return new Integer(var1.getBatchSize());
  1175.          case 30:
  1176.             return new Integer(var1.getMaxBacklog());
  1177.          default:
  1178.             throw new LDAPException("invalid option", 89);
  1179.       }
  1180.    }
  1181.  
  1182.    public void setOption(int var1, Object var2) throws LDAPException {
  1183.       if (var1 == 17) {
  1184.          int var4 = (Integer)var2;
  1185.          this.protocolVersion = var4;
  1186.       } else {
  1187.          setOption(var1, var2, this.defaultConstraints);
  1188.          if (var1 == 30 && this.field_0 != null) {
  1189.             int var3 = (Integer)var2;
  1190.             if (var3 >= 1) {
  1191.                this.field_0.setMaxBacklog(var3);
  1192.             }
  1193.          }
  1194.  
  1195.       }
  1196.    }
  1197.  
  1198.    private static void setOption(int var0, Object var1, LDAPSearchConstraints var2) throws LDAPException {
  1199.       try {
  1200.          switch (var0) {
  1201.             case 2:
  1202.                var2.setDereference((Integer)var1);
  1203.                return;
  1204.             case 3:
  1205.                var2.setMaxResults((Integer)var1);
  1206.                return;
  1207.             case 4:
  1208.                var2.setTimeLimit((Integer)var1);
  1209.                return;
  1210.             case 8:
  1211.                var2.setReferrals((Boolean)var1);
  1212.                return;
  1213.             case 9:
  1214.                var2.setRebindProc((LDAPRebind)var1);
  1215.                return;
  1216.             case 10:
  1217.                var2.setHopLimit((Integer)var1);
  1218.                return;
  1219.             case 11:
  1220.                if (var1 == null) {
  1221.                   var2.setClientControls((LDAPControl[])null);
  1222.                   return;
  1223.                } else if (var1 instanceof LDAPControl) {
  1224.                   var2.setClientControls((LDAPControl)var1);
  1225.                   return;
  1226.                } else {
  1227.                   if (var1 instanceof LDAPControl[]) {
  1228.                      var2.setClientControls((LDAPControl[])var1);
  1229.                      return;
  1230.                   }
  1231.  
  1232.                   throw new LDAPException("invalid LDAPControl", 89);
  1233.                }
  1234.             case 12:
  1235.                if (var1 == null) {
  1236.                   var2.setServerControls((LDAPControl[])null);
  1237.                   return;
  1238.                } else if (var1 instanceof LDAPControl) {
  1239.                   var2.setServerControls((LDAPControl)var1);
  1240.                   return;
  1241.                } else {
  1242.                   if (var1 instanceof LDAPControl[]) {
  1243.                      var2.setServerControls((LDAPControl[])var1);
  1244.                      return;
  1245.                   }
  1246.  
  1247.                   throw new LDAPException("invalid LDAPControl", 89);
  1248.                }
  1249.             case 20:
  1250.                var2.setBatchSize((Integer)var1);
  1251.                return;
  1252.             case 30:
  1253.                int var3 = (Integer)var1;
  1254.                if (var3 < 1) {
  1255.                   throw new LDAPException("MAXBACKLOG must be at least 1", 89);
  1256.                }
  1257.  
  1258.                var2.setMaxBacklog((Integer)var1);
  1259.                return;
  1260.             default:
  1261.                throw new LDAPException("invalid option", 89);
  1262.          }
  1263.       } catch (ClassCastException var4) {
  1264.          throw new LDAPException("invalid option value", 89);
  1265.       }
  1266.    }
  1267.  
  1268.    public LDAPControl[] getResponseControls() {
  1269.       LDAPControl[] var1 = null;
  1270.       Hashtable var2 = this.m_responseControlTable;
  1271.       synchronized(var2){}
  1272.  
  1273.       try {
  1274.          Vector var4 = (Vector)this.m_responseControlTable.get(this.field_0);
  1275.          if (var4 != null) {
  1276.             int var5 = 0;
  1277.  
  1278.             for(int var6 = var4.size(); var5 < var6; ++var5) {
  1279.                ResponseControl var7 = (ResponseControl)var4.elementAt(var5);
  1280.                if (var7.getConnection().equals(this)) {
  1281.                   var1 = var7.getControls();
  1282.                   var4.removeElementAt(var5);
  1283.                   break;
  1284.                }
  1285.             }
  1286.          }
  1287.       } catch (Throwable var9) {
  1288.          throw var9;
  1289.       }
  1290.  
  1291.       return var1;
  1292.    }
  1293.  
  1294.    public LDAPSearchConstraints getSearchConstraints() {
  1295.       return this.defaultConstraints;
  1296.    }
  1297.  
  1298.    private synchronized LDAPResponseListener getResponseListener() {
  1299.       if (this.responseListeners == null) {
  1300.          this.responseListeners = new Vector(5);
  1301.       }
  1302.  
  1303.       LDAPResponseListener var1;
  1304.       if (this.responseListeners.size() < 1) {
  1305.          var1 = new LDAPResponseListener(this);
  1306.       } else {
  1307.          var1 = (LDAPResponseListener)this.responseListeners.elementAt(0);
  1308.          this.responseListeners.removeElementAt(0);
  1309.       }
  1310.  
  1311.       return var1;
  1312.    }
  1313.  
  1314.    private synchronized LDAPSearchListener getSearchListener(LDAPSearchConstraints var1) {
  1315.       if (this.searchListeners == null) {
  1316.          this.searchListeners = new Vector(5);
  1317.       }
  1318.  
  1319.       LDAPSearchListener var2;
  1320.       if (this.searchListeners.size() < 1) {
  1321.          var2 = new LDAPSearchListener(this, var1);
  1322.       } else {
  1323.          var2 = (LDAPSearchListener)this.searchListeners.elementAt(0);
  1324.          this.searchListeners.removeElementAt(0);
  1325.       }
  1326.  
  1327.       return var2;
  1328.    }
  1329.  
  1330.    private synchronized void releaseResponseListener(LDAPResponseListener var1) {
  1331.       if (this.responseListeners == null) {
  1332.          this.responseListeners = new Vector(5);
  1333.       }
  1334.  
  1335.       var1.reset();
  1336.       this.responseListeners.addElement(var1);
  1337.    }
  1338.  
  1339.    synchronized void releaseSearchListener(LDAPSearchListener var1) {
  1340.       if (this.searchListeners == null) {
  1341.          this.searchListeners = new Vector(5);
  1342.       }
  1343.  
  1344.       var1.reset();
  1345.       this.searchListeners.addElement(var1);
  1346.    }
  1347.  
  1348.    void checkMsg(JDAPMessage var1) throws LDAPException {
  1349.       if (var1.getProtocolOp() instanceof JDAPResult) {
  1350.          JDAPResult var4 = (JDAPResult)var1.getProtocolOp();
  1351.          int var3 = var4.getResultCode();
  1352.          if (var3 != 0) {
  1353.             if (var3 == 10) {
  1354.                throw new LDAPReferralException("referral", var3, var4.getReferrals());
  1355.             } else if (var3 == 9) {
  1356.                throw new LDAPReferralException("referral", var3, var4.getErrorMessage());
  1357.             } else {
  1358.                throw new LDAPException("error result", var3, var4.getErrorMessage(), var4.getMatchedDN());
  1359.             }
  1360.          }
  1361.       } else if (var1.getProtocolOp() instanceof JDAPSearchResultReference) {
  1362.          String[] var2 = ((JDAPSearchResultReference)var1.getProtocolOp()).getUrls();
  1363.          throw new LDAPReferralException("referral", 0, var2);
  1364.       }
  1365.    }
  1366.  
  1367.    void setResponseControls(LDAPConnThread var1, ResponseControl var2) {
  1368.       Hashtable var3 = this.m_responseControlTable;
  1369.       synchronized(var3){}
  1370.  
  1371.       try {
  1372.          Vector var5 = (Vector)this.m_responseControlTable.get(var1);
  1373.          if (var5 != null && var5.size() > 0) {
  1374.             for(int var6 = var5.size() - 1; var6 >= 0; --var6) {
  1375.                ResponseControl var7 = (ResponseControl)var5.elementAt(var6);
  1376.                if (var7.getConnection().equals(this) && (var2 == null || var2.getMsgID() != var7.getMsgID())) {
  1377.                   var5.removeElement(var7);
  1378.                }
  1379.             }
  1380.          } else if (var2 != null) {
  1381.             var5 = new Vector();
  1382.          }
  1383.  
  1384.          if (var2 != null) {
  1385.             var5.addElement(var2);
  1386.             this.m_responseControlTable.put(var1, var5);
  1387.          }
  1388.  
  1389.          Enumeration var10 = this.m_attachedList.elements();
  1390.  
  1391.          while(var10.hasMoreElements()) {
  1392.             LDAPConnThread var11 = (LDAPConnThread)var10.nextElement();
  1393.             if (!((Thread)var11).isAlive()) {
  1394.                this.m_responseControlTable.remove(var11);
  1395.                this.m_attachedList.removeElement(var11);
  1396.             }
  1397.          }
  1398.       } catch (Throwable var9) {
  1399.          throw var9;
  1400.       }
  1401.  
  1402.       if (this.m_attachedList.indexOf(var1) < 0) {
  1403.          this.m_attachedList.addElement(var1);
  1404.       }
  1405.  
  1406.    }
  1407.  
  1408.    private LDAPConnection prepareReferral(LDAPUrl var1, LDAPSearchConstraints var2) throws LDAPException {
  1409.       LDAPConnection var3 = new LDAPConnection(this.getSocketFactory());
  1410.       var3.setOption(8, new Boolean(true));
  1411.       var3.setOption(9, var2.getRebindProc());
  1412.       var3.setOption(17, new Integer(this.protocolVersion));
  1413.       var3.setOption(10, new Integer(var2.getHopLimit() - 1));
  1414.       var3.connect(var1.getHost(), var1.getPort());
  1415.       return var3;
  1416.    }
  1417.  
  1418.    LDAPConnection createReferralConnection(LDAPReferralException var1, LDAPSearchConstraints var2) throws LDAPException {
  1419.       if (var2.getHopLimit() <= 0) {
  1420.          throw new LDAPException("exceed hop limit", ((LDAPException)var1).getLDAPResultCode(), ((LDAPException)var1).getLDAPErrorMessage());
  1421.       } else if (!var2.getReferrals()) {
  1422.          throw var1;
  1423.       } else {
  1424.          LDAPUrl[] var3 = var1.getURLs();
  1425.          if (var3 != null && var3.length > 0 && !var3[0].equals("")) {
  1426.             LDAPConnection var4 = null;
  1427.             var4 = this.prepareReferral(var3[0], var2);
  1428.             String var5 = var3[0].getDN();
  1429.             if (var5 == null || var5.equals("")) {
  1430.                var5 = this.boundDN;
  1431.             }
  1432.  
  1433.             var4.authenticate(this.protocolVersion, var5, this.boundPasswd);
  1434.             return var4;
  1435.          } else {
  1436.             throw new LDAPException("No target URL in referral", 94);
  1437.          }
  1438.       }
  1439.    }
  1440.  
  1441.    void performReferrals(LDAPReferralException var1, LDAPSearchConstraints var2, int var3, String var4, int var5, String var6, String[] var7, boolean var8, LDAPModification[] var9, LDAPEntry var10, LDAPAttribute var11, Vector var12) throws LDAPException {
  1442.       if (var2.getHopLimit() <= 0) {
  1443.          throw new LDAPException("exceed hop limit", ((LDAPException)var1).getLDAPResultCode(), ((LDAPException)var1).getLDAPErrorMessage());
  1444.       } else if (!var2.getReferrals()) {
  1445.          if (var3 == 3) {
  1446.             LDAPSearchResults var21 = new LDAPSearchResults();
  1447.             var21.add(var1);
  1448.             var12.addElement(var21);
  1449.          } else {
  1450.             throw var1;
  1451.          }
  1452.       } else {
  1453.          LDAPUrl[] var13 = var1.getURLs();
  1454.          if (var13 != null) {
  1455.             for(int var14 = 0; var14 < var13.length; ++var14) {
  1456.                String var15 = var13[var14].getDN();
  1457.                Object var16 = null;
  1458.                String var22;
  1459.                if (var15 != null && !var15.equals("")) {
  1460.                   var22 = var15;
  1461.                } else {
  1462.                   var22 = var4;
  1463.                }
  1464.  
  1465.                if (var13[var14].getUrl().indexOf("?base") > -1) {
  1466.                   var5 = 0;
  1467.                }
  1468.  
  1469.                LDAPSearchConstraints var17 = (LDAPSearchConstraints)var2.clone();
  1470.                var17.setHopLimit(var2.getHopLimit() - 1);
  1471.  
  1472.                try {
  1473.                   if (this.m_referralConnection != null && var13[var14].getHost().equals(this.m_referralConnection.host) && var13[var14].getPort() == this.m_referralConnection.port) {
  1474.                      this.performReferrals(this.m_referralConnection, var17, var3, var22, var5, var6, var7, var8, var9, var10, var11, var12);
  1475.                      continue;
  1476.                   }
  1477.                } catch (LDAPException var20) {
  1478.                   if (var20.getLDAPResultCode() != 50) {
  1479.                      throw var20;
  1480.                   }
  1481.                }
  1482.  
  1483.                LDAPConnection var18 = null;
  1484.                var18 = this.prepareReferral(var13[var14], var2);
  1485.                if (var2.getRebindProc() == null) {
  1486.                   var18.authenticate((String)null, (String)null);
  1487.                } else {
  1488.                   LDAPRebindAuth var19 = var2.getRebindProc().getRebindAuthentication(var13[var14].getHost(), var13[var14].getPort());
  1489.                   var18.authenticate(var19.getDN(), var19.getPassword());
  1490.                }
  1491.  
  1492.                this.performReferrals(var18, var17, var3, var22, var5, var6, var7, var8, var9, var10, var11, var12);
  1493.             }
  1494.  
  1495.          }
  1496.       }
  1497.    }
  1498.  
  1499.    void performReferrals(LDAPConnection var1, LDAPSearchConstraints var2, int var3, String var4, int var5, String var6, String[] var7, boolean var8, LDAPModification[] var9, LDAPEntry var10, LDAPAttribute var11, Vector var12) throws LDAPException {
  1500.       LDAPSearchResults var13 = null;
  1501.  
  1502.       try {
  1503.          switch (var3) {
  1504.             case 3:
  1505.                var13 = var1.search(var4, var5, var6, var7, var8, var2);
  1506.                if (var13 != null) {
  1507.                   var13.closeOnCompletion(var1);
  1508.                   var12.addElement(var13);
  1509.                } else if (this.m_referralConnection == null || !var1.equals(this.m_referralConnection)) {
  1510.                   var1.disconnect();
  1511.                }
  1512.                break;
  1513.             case 6:
  1514.                var1.modify(var4, var9, var2);
  1515.                break;
  1516.             case 8:
  1517.                if (var4 != null && !var4.equals("")) {
  1518.                   var10.setDN(var4);
  1519.                }
  1520.  
  1521.                var1.add(var10, var2);
  1522.                break;
  1523.             case 10:
  1524.                var1.delete(var4, var2);
  1525.                break;
  1526.             case 12:
  1527.                var1.rename(var4, var6, var8, var2);
  1528.                break;
  1529.             case 14:
  1530.                boolean var16 = var1.compare(var4, var11, var2);
  1531.                var12.addElement(new Boolean(var16));
  1532.          }
  1533.       } catch (LDAPException var19) {
  1534.          throw var19;
  1535.       } finally {
  1536.          if (var1 != null && (var3 != 3 || var13 == null) && (this.m_referralConnection == null || !var1.equals(this.m_referralConnection))) {
  1537.             var1.disconnect();
  1538.          }
  1539.  
  1540.       }
  1541.  
  1542.    }
  1543.  
  1544.    private LDAPExtendedOperation performExtendedReferrals(LDAPReferralException var1, LDAPSearchConstraints var2, LDAPExtendedOperation var3) throws LDAPException {
  1545.       if (var2.getHopLimit() <= 0) {
  1546.          throw new LDAPException("exceed hop limit", ((LDAPException)var1).getLDAPResultCode(), ((LDAPException)var1).getLDAPErrorMessage());
  1547.       } else if (!var2.getReferrals()) {
  1548.          throw var1;
  1549.       } else {
  1550.          LDAPUrl[] var4 = var1.getURLs();
  1551.          if (var4 == null) {
  1552.             return null;
  1553.          } else {
  1554.             for(int var5 = 0; var5 < var4.length; ++var5) {
  1555.                try {
  1556.                   LDAPConnection var6 = this.prepareReferral(var4[var5], var2);
  1557.                   LDAPExtendedOperation var7 = var6.extendedOperation(var3);
  1558.                   var6.disconnect();
  1559.                   return var7;
  1560.                }
  1561.             }
  1562.  
  1563.             return null;
  1564.          }
  1565.       }
  1566.    }
  1567.  
  1568.    public synchronized Object clone() {
  1569.       try {
  1570.          LDAPConnection var1 = (LDAPConnection)super.clone();
  1571.          if (this.field_0 == null) {
  1572.             LDAPSearchConstraints var2 = this.defaultConstraints;
  1573.             if (this.saslBind) {
  1574.                this.saslBind(false);
  1575.             } else {
  1576.                this.bind(this.protocolVersion, false, var2);
  1577.             }
  1578.          }
  1579.  
  1580.          var1.defaultConstraints = (LDAPSearchConstraints)this.defaultConstraints.clone();
  1581.          var1.responseListeners = null;
  1582.          var1.searchListeners = null;
  1583.          var1.bound = this.bound;
  1584.          var1.host = this.host;
  1585.          var1.port = this.port;
  1586.          var1.boundDN = this.boundDN;
  1587.          var1.boundPasswd = this.boundPasswd;
  1588.          var1.prevBoundDN = this.prevBoundDN;
  1589.          var1.prevBoundPasswd = this.prevBoundPasswd;
  1590.          var1.m_anonymousBound = this.m_anonymousBound;
  1591.          var1.m_factory = this.m_factory;
  1592.          var1.field_0 = this.field_0;
  1593.          Hashtable var3 = m_threadConnTable;
  1594.          synchronized(var3){}
  1595.  
  1596.          label59: {
  1597.             Object var10;
  1598.             try {
  1599.                Vector var5 = (Vector)m_threadConnTable.get(this.field_0);
  1600.                if (var5 != null) {
  1601.                   var5.addElement(var1);
  1602.                   break label59;
  1603.                }
  1604.  
  1605.                var10 = null;
  1606.             } catch (Throwable var8) {
  1607.                throw var8;
  1608.             }
  1609.  
  1610.             return var10;
  1611.          }
  1612.  
  1613.          var1.field_0.register(var1);
  1614.          return var1;
  1615.       } catch (Exception var9) {
  1616.          return null;
  1617.       }
  1618.    }
  1619.  
  1620.    void resultRetrieved() {
  1621.       if (this.field_0 != null) {
  1622.          this.field_0.resultRetrieved();
  1623.       }
  1624.  
  1625.    }
  1626.  
  1627.    private static boolean checkCommunicator() {
  1628.       try {
  1629.          Method var0 = LDAPCheckComm.getMethod("netscape.security.PrivilegeManager", "enablePrivilege");
  1630.          if (var0 == null) {
  1631.             return false;
  1632.          }
  1633.  
  1634.          Object[] var5 = new Object[]{new String("UniversalConnect")};
  1635.          var0.invoke((Object)null, var5);
  1636.          return true;
  1637.       } catch (LDAPException var2) {
  1638.          String var4 = "Exception: " + var2.toString();
  1639.       } catch (Exception var3) {
  1640.          String var1 = "Exception on invoking enablePrivilege: " + ((Throwable)var3).toString();
  1641.       }
  1642.  
  1643.       return false;
  1644.    }
  1645.  
  1646.    public static boolean isNetscape() {
  1647.       return isCommunicator;
  1648.    }
  1649.  
  1650.    static void printDebug(String var0) {
  1651.    }
  1652.  
  1653.    public static void main(String[] var0) {
  1654.       System.out.println("LDAP SDK Version is " + SdkVersion);
  1655.       System.out.println("LDAP Protocol Version is " + ProtocolVersion);
  1656.    }
  1657. }
  1658.